import cloudHelper from '../helpers/cloud/cloud_helper';
// 使用统一配置入口引用模型
const { TeamModel } = require('../../config/models_config');
import SmartCache from '../../helpers/smart_cache';

// 创建团队缓存实例
const teamCache = new SmartCache('team', 5 * 60 * 1000); // 5分钟缓存

/**
 * 团队仓储层
 * 负责团队成员数据的持久化和检索
 */
class TeamRepository {
  /**
   * 获取项目团队成员列表
   * @param {String} projectId 项目ID
   * @param {Object} params 查询参数
   */
  async getProjectTeamList(projectId, params = {}) {
    if (!projectId) throw new Error('项目ID不能为空');
    
    const cacheKey = `team:${projectId}:${JSON.stringify(params)}`;
    
    try {
      // 尝试从缓存获取
      return await teamCache.get(cacheKey, async () => {
        // 从云函数获取数据
        const result = await cloudHelper.callCloudData('team/list', {
          projectId,
          ...params
        });
        
        // 转换为领域模型
        if (result && result.list) {
          result.list = result.list.map(item => new TeamModel(item));
        }
        
        return result;
      });
    } catch (err) {
      console.error('[TeamRepository] getProjectTeamList 错误:', err);
      throw err;
    }
  }
  
  /**
   * 获取团队成员详情
   * @param {String} id 成员ID
   */
  async getTeamMemberById(id) {
    if (!id) throw new Error('成员ID不能为空');
    
    const cacheKey = `member:${id}`;
    
    try {
      // 尝试从缓存获取
      return await teamCache.get(cacheKey, async () => {
        // 从云函数获取数据
        const result = await cloudHelper.callCloudData('team/detail', {id});
        
        // 转换为领域模型
        return result ? new TeamModel(result) : null;
      });
    } catch (err) {
      console.error('[TeamRepository] getTeamMemberById 错误:', err);
      throw err;
    }
  }
  
  /**
   * 添加团队成员
   * @param {TeamModel} member 团队成员模型
   */
  async addTeamMember(member) {
    try {
      // 验证成员数据
      const validation = member.validate();
      if (!validation.valid) {
        throw new Error('成员数据验证失败: ' + JSON.stringify(validation.errors));
      }
      
      // 转换为存储格式
      const data = member.toStorage();
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('team/add', {
        member: data
      });
      
      // 清除相关缓存
      teamCache.removeByPattern(`^team:${member.projectId}:`);
      
      return result;
    } catch (err) {
      console.error('[TeamRepository] addTeamMember 错误:', err);
      throw err;
    }
  }
  
  /**
   * 更新团队成员
   * @param {TeamModel} member 团队成员模型
   */
  async updateTeamMember(member) {
    try {
      if (!member._id) throw new Error('更新成员时ID不能为空');
      
      // 验证成员数据
      const validation = member.validate();
      if (!validation.valid) {
        throw new Error('成员数据验证失败: ' + JSON.stringify(validation.errors));
      }
      
      // 转换为存储格式
      const data = member.toStorage();
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('team/edit', {
        id: member._id,
        data: data
      });
      
      // 清除相关缓存
      teamCache.removeByPattern(`^member:${member._id}`);
      teamCache.removeByPattern(`^team:${member.projectId}:`);
      
      return result;
    } catch (err) {
      console.error('[TeamRepository] updateTeamMember 错误:', err);
      throw err;
    }
  }
  
  /**
   * 移除团队成员
   * @param {String} memberId 成员ID
   * @param {String} projectId 项目ID
   */
  async removeTeamMember(memberId, projectId) {
    try {
      if (!memberId) throw new Error('成员ID不能为空');
      if (!projectId) throw new Error('项目ID不能为空');
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('team/remove', {
        id: memberId
      });
      
      // 清除相关缓存
      teamCache.removeByPattern(`^member:${memberId}`);
      teamCache.removeByPattern(`^team:${projectId}:`);
      
      return result;
    } catch (err) {
      console.error('[TeamRepository] removeTeamMember 错误:', err);
      throw err;
    }
  }
  
  /**
   * 更新团队成员权限
   * @param {String} memberId 成员ID
   * @param {String} projectId 项目ID
   * @param {Object} permissions 权限配置
   */
  async updateMemberPermissions(memberId, projectId, permissions) {
    try {
      if (!memberId) throw new Error('成员ID不能为空');
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('team/permissions', {
        id: memberId,
        permissions
      });
      
      // 清除相关缓存
      teamCache.removeByPattern(`^member:${memberId}`);
      teamCache.removeByPattern(`^team:${projectId}:`);
      
      return result;
    } catch (err) {
      console.error('[TeamRepository] updateMemberPermissions 错误:', err);
      throw err;
    }
  }
  
  /**
   * 批量更新团队工作量分配
   * @param {String} projectId 项目ID
   * @param {Array} workloadData 工作量分配数据数组 [{memberId, workload}]
   */
  async updateTeamWorkload(projectId, workloadData) {
    try {
      if (!projectId) throw new Error('项目ID不能为空');
      if (!Array.isArray(workloadData)) throw new Error('工作量数据格式错误');
      
      // 调用云函数
      const result = await cloudHelper.callCloudSumbit('team/workload', {
        projectId,
        workloadData
      });
      
      // 清除相关缓存
      teamCache.removeByPattern(`^team:${projectId}:`);
      workloadData.forEach(item => {
        teamCache.removeByPattern(`^member:${item.memberId}`);
      });
      
      return result;
    } catch (err) {
      console.error('[TeamRepository] updateTeamWorkload 错误:', err);
      throw err;
    }
  }
}

export default new TeamRepository(); 